package com.wusiwei.service.impl;

import com.wusiwei.common.Result;
import com.wusiwei.entity.User;
import com.wusiwei.mapper.UserMapper;
import com.wusiwei.service.UserService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.stereotype.Service;
import org.springframework.util.StringUtils;

import java.time.LocalDateTime;

/**
 * 用户服务实现类
 */
@Service
public class UserServiceImpl implements UserService {

    private static final Logger logger = LoggerFactory.getLogger(UserServiceImpl.class);

    @Autowired
    private UserMapper userMapper;

    @Autowired
    private PasswordEncoder passwordEncoder;

//    /**
//     * 用户登录
//     *
//     * @param loginDTO 登录信息
//     * @return 登录结果
//     */
//    @Override
//    public Result<User> login(LoginDTO loginDTO) {
//        // 参数校验
//        if (!StringUtils.hasText(loginDTO.getUsername()) || !StringUtils.hasText(loginDTO.getPassword())) {
//            return Result.error("用户名和密码不能为空");
//        }
//
//        // 查询用户
//        User user = userMapper.findByUsername(loginDTO.getUsername());
//        if (user == null) {
//            return Result.error("用户不存在");
//        }
//
//        // 验证密码 -  项目中应使用加密算法比较密码
//        if (!passwordEncoder.matches(loginDTO.getPassword(), user.getPassword())) {
//            return Result.error("密码错误");
//        }
//
//        // 登录成功，返回用户信息（密码置空）
//        user.setPassword(null);
//        return Result.success(user);
//    }

//    /**
//     * 用户注册
//     *
//     * @param registerDTO 注册信息
//     * @return 注册结果
//     */
//    @Override
//    public Result<User> register(RegisterDTO registerDTO) {
//        // 参数校验
//        if (!StringUtils.hasText(registerDTO.getUsername()) || !StringUtils.hasText(registerDTO.getPassword())
//                || !StringUtils.hasText(registerDTO.getConfirmPassword())) {
//            return Result.error("用户名和密码不能为空");
//        }
//
//        // 检查两次密码是否一致
//        if (!registerDTO.getPassword().equals(registerDTO.getConfirmPassword())) {
//            return Result.error("两次密码不一致");
//        }
//
//        // 检查用户名是否已存在
//        User existUser = userMapper.findByUsername(registerDTO.getUsername());
//        if (existUser != null) {
//            return Result.error("用户名已存在");
//        }
//
//        // 创建用户并保存
//        User user = new User();
//        user.setUsername(registerDTO.getUsername());
//        user.setPassword(passwordEncoder.encode(registerDTO.getPassword()));
//        user.setRealName(registerDTO.getRealName());
//        user.setEmail(registerDTO.getEmail());
//        user.setPhone(registerDTO.getPhone());
//        user.setStatus((byte) 1); // 1表示正常状态
//        user.setCreateTime(LocalDateTime.now());
//
//        userMapper.insert(user);
//
//        // 注册成功，返回用户信息（密码置空）
//        user.setPassword(null);
//        return Result.success(user);
//    }

    /**
     * 根据用户名查询用户
     *
     * @param username 用户名
     * @return 用户对象
     */
    @Override
    public User findByUsername(String username) {
        return userMapper.findByUsername(username);
    }

    /**
     * 更新用户密码
     *
     * @param userId      用户ID
     * @param newPassword 新密码
     * @return 操作结果
     */
    @Override
    public Result<Void> updatePassword(Long userId, String newPassword) {
        // 参数校验
        if (userId == null || !StringUtils.hasText(newPassword)) {
            return Result.error("用户ID和新密码不能为空");
        }

        // 查询用户是否存在
        User user = userMapper.findById(userId);
        if (user == null) {
            return Result.error("用户不存在");
        }

        // 更新密码 -  项目中应该先加密
        user.setPassword(passwordEncoder.encode(newPassword));
        userMapper.update(user);
        return Result.success();
    }

    /**
     * 用户注册
     *
     * @param user 用户信息
     * @return 注册成功的用户
     */
    @Override
    public User register(User user) {
        // 验证用户名是否已存在
        User existingUser = userMapper.findByUsername(user.getUsername());
        if (existingUser != null) {
            throw new RuntimeException("用户名已存在");
        }

        // 设置用户默认值
        user.setStatus((byte) 1);  // 默认启用
        user.setCreateTime(LocalDateTime.now());

        // 确保设置真实姓名，如果没有提供则使用用户名
        if (user.getRealName() == null || user.getRealName().isEmpty()) {
            user.setRealName(user.getUsername());
        }

        // 加密密码
        user.setPassword(passwordEncoder.encode(user.getPassword()));

        // 添加用户
        userMapper.insert(user);
        return user;
    }

    @Override
    public User update(User user) {
        if (user.getPassword() != null && !user.getPassword().isEmpty()) {
            user.setPassword(passwordEncoder.encode(user.getPassword()));
        }
        userMapper.update(user);
        return user;
    }

//    @Override
//    public void delete(long id) {
//        userMapper.delete(id);
//    }

    @Override
    public User getById(long id) {
        return userMapper.findById(id);
    }

//    @Override
//    public List<User> list() {
//        return userMapper.findAll();
//    }

    /**
     * 修改密码
     *
     * @param username    用户名
     * @param oldPassword 旧密码
     * @param newPassword 新密码
     * @return 是否修改成功
     */
    @Override
    public boolean changePassword(String username, String oldPassword, String newPassword) {
        User user = findByUsername(username);
        if (user == null) {
            return false;
        }

        // 验证旧密码
        if (!passwordEncoder.matches(oldPassword, user.getPassword())) {
            return false;
        }

        // 更新密码
        user.setPassword(passwordEncoder.encode(newPassword));
        try {
            userMapper.update(user);
            return true;
        } catch (Exception e) {
            logger.error("修改密码失败", e);
            return false;
        }
    }
} 